package com.wc.alorithm_blue_bridge._图论.装修;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * @Author congge
 * @Date 2024/5/13 14:59
 * @description 题意：
 * 小蓝需要一些木材来装修他的新房子，他找来了一棵有 n 个结点的树，每
 * 条边有一个权值。他想要在树上砍下一些木材，每根木材由一条边和其两端的
 * 结点构成，其权值为这条边的权值，所以一个结点最多属于一根木材。小蓝想
 * 知道，在树上砍下的木材的权值和最大是多少？
 * 输入：
 * 输入的第一行包含一个正整数 n 。
 * 接下来 n − 1 行，第 i 行包含三个整数 ui, vi, wi ，相邻整数之间使用一个空
 * 格分隔，表示结点 ui 和 vi 之间有一条权值为 wi 的边。
 * <p>
 * 输出：
 * 输出一行包含一个整数表示答案。
 * <p>
 * 样例
 * 输入：
 * 6
 * 1 2 1
 * 1 3 5
 * 2 4 2
 * 2 5 4
 * 3 6 2
 * 输出：
 * 9
 * 样例解释
 * 选择第 2, 4 条边作为木材，边权值和为 5 + 4 = 9
 */
public class Main {
    static FastReader sc = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);
    static int N = 1000010, M = N << 1, idx = 1;
    static int[] h = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    // f[i][j] 表示跟为j = 0选择了给了父边, j = 1表示给了孩子的边, j = 2表示自己没被选择
    static long[][] f = new long[N][3];
    static int n;

    public static void main(String[] args) {
        n = sc.nextInt();
        for (int i = 1; i < n; i++) {
            int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt();
            add(a, b, c);
            add(b, a, c);
        }
        dfs(1, -1);
        out.println(Math.max(f[1][1], f[1][2]));
        out.flush();
    }

    static void add(int a, int b, int c) {
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx++;
    }

    static void dfs(int u, int fa) {
        f[u][2] = 0;
        for (int i = h[u]; i > 0; i = ne[i]) {
            int j = e[i];
            if (j == fa) continue;
            dfs(j, u);
            f[u][2] += Math.max(f[j][1], f[j][2]);
            f[u][0] += Math.max(f[j][1], f[j][2]);
        }

        for (int i = h[u]; i > 0; i = ne[i]) {
            int j = e[i];
            if (j == fa) continue;
            // 看是选择了那一条边, 如果选择了j这条边那就是j条边的权值加上, 然后其他的减去
            f[u][1] = Math.max(f[u][1], w[i] + f[j][0] + f[u][2] - Math.max(f[j][1], f[j][2]));
        }
    }

}

class FastReader {
    StringTokenizer st;
    BufferedReader br;

    FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    String nextLine() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    // 是否由下一个
    boolean hasNext() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                String line = br.readLine();
                if (line == null)
                    return false;
                st = new StringTokenizer(line);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return true;
    }
}